.TH std::unary_function 3 "2024.06.10" "http://cppreference.com" "C++ Standard Libary"
.SH NAME
std::unary_function \- std::unary_function

.SH Synopsis
   Defined in header <functional>
   template< typename ArgumentType, typename ResultType >  (deprecated in C++11)
   struct unary_function;                                  (removed in C++17)

   std::unary_function is a base class for creating function objects with one argument.

   std::unary_function does not define operator(); it is expected that derived classes
   will define this. std::unary_function provides only two types - argument_type and
   result_type - defined by the template parameters.

   Some standard library function object adaptors, such as std::not1, require the
   function objects they adapt to have certain types defined; std::not1 requires the
   function object being adapted to have a type named argument_type. Deriving function
   objects that take one argument from std::unary_function is an easy way to make them
   compatible with those adaptors.

   std::unary_function is deprecated in C++11.

.SH Member types

   Type          Definition
   argument_type ArgumentType
   result_type   ResultType

.SH Example


// Run this code

 #include <algorithm>
 #include <functional>
 #include <iostream>
 #include <vector>

 struct less_than_7 : std::unary_function<int, bool>
 {
     bool operator()(int i) const { return i < 7; }
 };

 int main()
 {
     std::vector<int> v(10, 7);
     v[0] = v[1] = v[2] = 6;

     std::cout << std::count_if(v.begin(), v.end(), std::not1(less_than_7()));

     // C++11 solution:
     // Cast to std::function<bool (int)> somehow - even with a lambda
     // std::cout << std::count_if(v.begin(), v.end(),
     //     std::not1(std::function<bool (int)>([](int i) { return i < 7; })));
 }

.SH Output:

 7

.SH See also

   function                  wraps callable object of any copy constructible type with
   \fI(C++11)\fP                   specified function call signature
                             \fI(class template)\fP
   move_only_function        wraps callable object of any type with specified function
   (C++23)                   call signature
                             \fI(class template)\fP
   ptr_fun                   creates an adaptor-compatible function object wrapper from
   (deprecated in C++11)     a pointer to function
   (removed in C++17)        \fI(function template)\fP
   pointer_to_unary_function adaptor-compatible wrapper for a pointer to unary function
   (deprecated in C++11)     \fI(class template)\fP
   (removed in C++17)
   binary_function           adaptor-compatible binary function base class
   (deprecated in C++11)     \fI(class template)\fP
   (removed in C++17)
